﻿using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace UnitTestProject1.Other {
    /**/
    namespace Test8 { }
    /*C# 数据结构*/
    namespace Test7 {
        [TestClass]
        public class Program {
            [TestMethod]
            public void Main1() {
                //Name myName = new Name("wang", "wei", "guo");
                //string fullName, inits;
                //fullName = myName.ToString();
                //inits = myName.Initials();
                //Console.WriteLine("My Name is {0}", fullName);
                //Console.WriteLine("Init is {0}", inits);
                //Console.ReadLine();

                //Collection names = new Collection();
                //names.Add("David");
                //names.Add("bernica");

                //foreach(Object name in names)
                //{
                //    Console.WriteLine(name);
                //}

                //Console.WriteLine("Count : " + names.Count());

                //Console.ReadLine();

                //int num1 = 100;
                //int num2 = 200;

                //Swap<int>(ref num1, ref num2);
                //Console.WriteLine(num1);
                //Console.WriteLine(num2);
                //Console.ReadLine();

                //int[] nums = new int[10000];
                //BuildArray(nums);
                //TimeSpan duration;
                //Timing2 time2 = new Timing2();
                //time2.startTime();
                //DisplayNums(nums);
                //DisplayNums(nums);
                //DisplayNums(nums);
                //time2.stopTime();
                //Console.WriteLine(time2.Result().TotalSeconds);
                ////duration = Process.GetCurrentProcess().TotalProcessorTime;
                ////Console.WriteLine(duration.TotalSeconds);
                //Console.ReadLine();

                //int[] numbers;
                //numbers = new int[] { 1, 2, 3 };
                //Type arrayType = numbers.GetType();
                //if(arrayType.IsArray)
                //{
                //    Console.WriteLine("This is a Array");
                //}
                //else
                //{
                //    Console.WriteLine("This is not a Array");

                //}
                //Console.ReadLine();

                //int[,] grades = new int[,]
                //{
                //    {1,82,74,89,100},
                //    {2,93,96,85,86}
                //};

                //int last_grade = grades.GetUpperBound(1);
                //double average = 0.0;
                //int total;
                //int last_student = grades.GetUpperBound(0);  //最后一个学生的index
                //for(int row=0;row<=last_student;row++)
                //{
                //    total = 0;
                //    for(int col=1;col<=last_grade;col++)
                //    {
                //        total += grades[row, col];
                //    }
                //    average = total / last_grade;
                //    Console.WriteLine(average);
                //}

                //ArrayList names = new ArrayList();
                //names.Add("Mike");
                //names.Add("Beata");
                //Console.WriteLine("The Original list of names: ");
                //foreach(Object name in names)
                //{
                //    Console.Write(name + " ");
                //}

                //string[] newNames = new string[] { "David", "Michael" };
                //ArrayList moreNames = new ArrayList();
                //moreNames.Add("wwg");

                //names.InsertRange(0, newNames);
                //names.AddRange(moreNames);

                //foreach (Object name in names)
                //{
                //    Console.Write(name + " ");
                //}


                //CArray nums = new CArray(10);
                //Random rnd = new Random(100);

                //for (int i = 0; i < 10;i++ )
                //{
                //    nums.Insert(rnd.Next(0,100));
                //}

                //nums.DisplayElements();

                //nums.SelectionSort();

                //Timing2 sortTime = new Timing2();
                //Random rnd = new Random(10000);
                //int numItems = 10000;
                //CArray theArray = new CArray(numItems);
                //for (int i = 0; i < numItems;i++ )
                //{
                //    theArray.Insert(rnd.Next(0,10000));
                //}

                //sortTime.startTime();
                //theArray.SelectionSort();
                //sortTime.stopTime();
                //Console.WriteLine("SelectionSort : " + sortTime.Result().TotalMilliseconds);
                //theArray.Clear();

                //for (int i = 0; i < numItems; i++)
                //{
                //    theArray.Insert((int)(rnd.NextDouble() * 100));
                //}

                //sortTime.startTime();
                //theArray.BubbleSort();
                //sortTime.stopTime();
                //Console.WriteLine("BubbleSort : " + sortTime.Result().TotalMilliseconds);
                //theArray.Clear();

                //int[] numbers = new int[100];
                //StreamReader numFile = File.OpenText(@"d:/wwgData/numbers.txt");
                //for (int i = 0; i < numbers.Length; i++)
                //{
                //    numbers[i] = Convert.ToInt32(numFile.ReadLine(), 10);
                //}

                //int searchNumber;
                //Console.Write("Enter a number to search for: ");
                //searchNumber = Convert.ToInt32(Console.ReadLine(), 10);

                //bool found;
                //found = SeqSearch(numbers, searchNumber);

                //Random random = new Random();
                //CArray mynums = new CArray(10);
                //for (int i = 0; i <= 9; i++)
                //{
                //    mynums.Insert(random.Next(10));
                //}
                //mynums.BubbleSort();

                //mynums.DisplayElements();
                //int position = mynums.binSearch(7);
                //if (position>-1)
                //{
                //    Console.WriteLine("found it");
                //}
                //else
                //{
                //    Console.WriteLine("not found it");
                //}

                ////回文
                //CStack alist = new CStack();
                //string ch;
                //string word = "sees";
                //bool ishui = true;
                //for (int x = 0; x < word.Length;x++ )
                //{
                //    alist.push(word.Substring(x, 1));
                //}
                //int pos = 0;
                //while(alist.count>0)
                //{
                //    ch = alist.pop().ToString(); //出栈，是最后一个字母
                //    if(ch != word.Substring(pos,1))
                //    {//不是回文
                //        ishui = false;
                //        break;
                //    }

                //    pos++;
                //}

                //if (ishui)
                //{
                //    Console.WriteLine("is hui");
                //}
                //else
                //{
                //    Console.WriteLine("no hui");

                //}


                //使用Stack完成表达式计算
                //Stack nums = new Stack();
                //Stack ops = new Stack();

                //string expression = "1 + 2 + 3 + 5";
                //Calculate(nums, ops, expression);
                //Console.WriteLine(nums.Pop());

                //int num, baseNum;
                //num = Convert.ToInt32(Console.ReadLine());
                //baseNum = Convert.ToInt32(Console.ReadLine());
                //MulBase(num, baseNum);

                //Queue[] numQueue = new Queue[10];//用于收集用的
                //int[] nums = new int[] { 91, 46, 85, 15, 92, 35, 31, 22 };
                //for (int i = 0; i < 10;i++ )
                //{
                //    numQueue[i] = new Queue();
                //}

                ////先各位发散
                //RSort(numQueue, nums, DigitType.ones);
                ////收集
                //BuildArray(numQueue, nums);

                ////十位发散
                //RSort(numQueue, nums, DigitType.tens);

                ////收集
                //BuildArray(numQueue, nums);
                //DisplayNums(nums);

                //byte[] ByteSet = new Byte[] { 2};
                //BitArray BitSet = new BitArray(ByteSet);
                //for (int bits = 0; bits <= BitSet.Count - 1; bits++)
                //{
                //    Console.Write(BitSet.Get(bits) + "");
                //}

                //int bits;
                //string[] binNumber = new string[8];
                //byte[] ByteSet = new Byte[] { 5 };
                //BitArray BitSet = new BitArray(ByteSet);
                //bits = 0;

                //int binary = 7;
                //for (int i = 0; i < BitSet.Count - 1;i++ )
                //{
                //    if(BitSet.Get(i)== true)
                //    {
                //        binNumber[binary] = "1";
                //    }
                //    else
                //    {
                //        binNumber[binary] = "0";
                //    }
                //    bits++;
                //    binary--;

                //    if((bits% 8)==0)
                //    {
                //        binary = 7;
                //        bits = 0;
                //        for(int j=0;j<=7;j++)
                //        {
                //            Console.Write(binNumber[j]);
                //        }
                //    }
                //}

                //string string1 = "Hello world";
                //int len = string1.Length;
                //int pos = string1.IndexOf(" ");
                //string firstWord, secondWord;
                //firstWord = string1.Substring(0, pos);
                //secondWord = string1.Substring(pos + 1);
                //Console.Write(firstWord);
                //Console.Write(",");
                //Console.Write(secondWord);

                //string astring = "now is a happy day";
                //ArrayList words = new ArrayList();
                //words = SplitWords(astring);
                //foreach (string word in words)
                //{
                //    Console.Write(word + ",");
                //}

                //string data = "Mike,McMillan,wwg,smm";
                //string[] sdata;
                //char[] delimiter = new char[] { ',' };
                //sdata = data.Split(delimiter, data.Length);
                //foreach(string word in sdata)
                //{
                //    Console.Write(word + " ");
                //}

                //string[] nouns = new string[] { "cat", "dog", "bird", "eggs", "bones" };
                //ArrayList pluralNouns = new ArrayList();
                //foreach(string noun in nouns)
                //{
                //    if(noun.EndsWith("s"))
                //    {

                //    }
                //}

                //string[] words = new string[] { "recieve", "decieve", "reciept" };
                //for (int i = 0; i <= words.GetUpperBound(0);i++ )
                //{
                //    words[i] = words[i].Replace("cie", "cei");
                //    Console.WriteLine(words[i]);
                //}

                //string[,] names = new string[,]
                //{
                //    {"1504","wwg","Ella","steve","Bob"},
                //    {"1133","Elizabeth","Alex","David","Joe"}
                //};

                //for (int outer=0;outer<=names.GetUpperBound(0);outer++)
                //{
                //    for (int inner=0;inner<=names.GetUpperBound(1);inner++)
                //    {
                //        Console.Write(names[outer,inner].PadRight(10)+" ");
                //    }
                //    Console.WriteLine();
                //}

                //string[] names = new string[] { " David", " Raymond", "Mike " };
                //showName(names);

                //StringBuilder stBuff = new StringBuilder("Ken Thompson");
                //Console.WriteLine(stBuff.Length.ToString());
                //Console.WriteLine(stBuff.Capacity.ToString());
                //Console.WriteLine(stBuff.MaxCapacity.ToString());

                //StringBuilder stBuff = new StringBuilder();
                //Console.WriteLine();
                //stBuff.AppendFormat("YOU order is for {0} widges ", 234);
                //Console.WriteLine(stBuff.ToString());

                //StringBuilder stBuff = new StringBuilder("noise in+++++string");
                //stBuff.Remove(9, 5);
                //Console.WriteLine(stBuff);

                //int size = 100000;
                //Timing2 timeSB = new Timing2();
                //Timing2 timeST = new Timing2();
                //for (int i = 0; i <= 0;i++ )
                //{
                //    timeSB.startTime();
                //    BuildSB(size);
                //    timeSB.stopTime();

                //    timeST.startTime();
                //    BuildString(size);
                //    timeST.stopTime();

                //    Console.WriteLine("sb size;" + size + ",time:" + timeSB.Result().TotalMilliseconds);
                //    Console.WriteLine("st size;" + size + ",time:" + timeST.Result().TotalMilliseconds);
                //}


                //string words = "08/14/57 46 02/25/59 45 06/05/85 18 08/14/57 46";
                //string regExp1 = "(?<dates>(//d{2}///d{2}///d{2}))//s(?<ages>(//d{2}))//s";

                //MatchCollection matchSet = Regex.Matches(words, regExp1);
                //int matchPos;
                //if (matchSet.Count > 0)
                //{
                //    foreach (Match aMatch in matchSet)
                //    {
                //        foreach (Capture aCapture in aMatch.Groups["dates"].Captures)
                //        {
                //            Console.WriteLine("date:" + aCapture.ToString());
                //        }
                //        foreach (Capture aCapture2 in aMatch.Groups["ages"].Captures)
                //        {
                //            Console.WriteLine("age:" + aCapture2.ToString());
                //        }

                //    }
                //}

                //string[] words = new string[] { "heal", "heel", "noah", "techno"};
                //string regExp = "h$"; //. 与字符串中任意字符匹配
                //MatchCollection aMatch;

                //foreach (string word in words)
                //{
                //    if (Regex.IsMatch(word, regExp))
                //    {
                //        aMatch = Regex.Matches(word, regExp);
                //        for (int i = 0; i < aMatch.Count; i++)
                //        {
                //            Console.Write(aMatch[i].Value + " ");
                //        }
                //    }

                //}

                //IPAddress myIPs = new IPAddress();
                //myIPs.Add("Mike", "192.111.111.0");
                //myIPs.Add("wwg", "120.0.0.1");
                //Console.WriteLine(myIPs.Count);
                //Console.WriteLine(myIPs.Item("wwg"));
                //myIPs.Clear();
                //Console.WriteLine(myIPs.Count);

                //IPAddress myips = new IPAddress(@"D://data.txt");
                //Console.WriteLine(myips.Count);
                //Console.WriteLine(myips.Item("wwg"));

                //KeyValuePair<string, int>[] gradeBook = new KeyValuePair<string, int>[10];
                //gradeBook[0] = new KeyValuePair<string, int>("McMillan", 99);
                //gradeBook[1] = new KeyValuePair<string, int>("Ruff", 64);

                //for (int i = 0; i <= gradeBook.GetUpperBound(0);i++ )
                //{
                //    Console.WriteLine(gradeBook[i].Key + ":" + gradeBook[i].Value);
                //}

                //string[] names = new string[99];
                //string name;
                //string[] someNames = new string[] { "David", "Jennifer", "Donnie", "Mayno","Raymod","Bernica","Clayton","Beata","Michael","wwg" };
                //int hashVal;
                //for (int i = 0; i < 10;i++ )

                //    name = someNames[i];
                //    hashVal = BetterHash(name, names);
                //    names[hashVal] = name;

                //}

                //ShowDistrib(names);

                //Hashtable symbols = new Hashtable(25);
                //symbols.Add("salary", 100000);
                //symbols.Add("name", "David Durr");
                //symbols.Add("age", 45);
                //symbols.Add("dept", "IT");
                //symbols["sex"] = "Male";
                //Console.WriteLine("The keys are: ");
                //foreach (Object key in symbols.Keys)
                //{
                //    Console.Write(key + ",");
                //}
                //Console.WriteLine();
                //foreach (object key in symbols.Keys)
                //{
                //    Console.WriteLine(key.ToString()+":"+symbols[key].ToString());
                //}

                //LinkList MyList = new LinkList();
                //ListIter iter = new ListIter(MyList);
                //string choice, value;

                //try
                //{
                //    iter.insertAfter("David");
                //    iter.insertAfter("Mike");
                //    iter.InsertBefore("Donnie");

                //    while(true)
                //    {
                //        Console.WriteLine("Enter your choice");
                //        choice = Console.ReadLine().ToLower();

                //        char[] onechar = choice.ToCharArray();

                //        switch (onechar[0])
                //        {
                //            case 'n':
                //                if((!MyList.IsEmpty())&&(!iter.AtEnd()))
                //                {
                //                    iter.NextLink();
                //                }
                //                else
                //                {
                //                    Console.WriteLine("can't move to next link");
                //                }
                //                break;
                //            case 'g':
                //                if(!MyList.IsEmpty())
                //                {
                //                    Console.WriteLine(iter.GetCurrent().Element);
                //                }
                //                else
                //                {
                //                    Console.WriteLine("list is empty");
                //                }
                //                break;
                //            case 'r':
                //                iter.Reset(); 
                //                break;
                //            case 's':
                //                if(!MyList.IsEmpty())
                //                {
                //                    MyList.ShowList();
                //                }
                //                else
                //                {
                //                    Console.WriteLine("list is empty");
                //                }
                //                break;
                //            case 'a':
                //                Console.WriteLine();
                //                Console.WriteLine("enter a value to insert");
                //                value = Console.ReadLine();
                //                iter.insertAfter(value);
                //                break;
                //            case 'b':
                //                Console.WriteLine();
                //                Console.WriteLine("enter a value to insert");
                //                value = Console.ReadLine();
                //                iter.InsertBefore(value);

                //                break;
                //            case 'c':
                //                break;
                //            case 'x':
                //                break;
                //        }
                //    }

                //}
                //catch (InsertBeforeHeaderException e)
                //{
                //    Console.WriteLine(e.Message);
                //}

                //LinkedListNode<string> node = new LinkedListNode<string>("Mike");
                //LinkedList<string> names = new LinkedList<string>();
                //names.AddFirst(node);
                //LinkedListNode<string> node1 = new LinkedListNode<string>("David");
                //names.AddAfter(node, node1);
                //LinkedListNode<string> node2 = new LinkedListNode<string>("Raymond");
                //names.AddAfter(node1, node2);
                //LinkedListNode<string> node3 = new LinkedListNode<string>(null);
                //LinkedListNode<string> aNode = names.First;

                //while (aNode!=null)
                //{
                //    Console.WriteLine(aNode.Value);
                //    aNode = aNode.Next;
                //}

                //BinarySearchTree nums = new BinarySearchTree();
                //nums.insert(23);
                //nums.insert(45);
                //nums.insert(16);
                //nums.insert(37);
                //nums.insert(3);
                //nums.insert(99);
                //nums.insert(22);

                //nums.InOrder(nums.root);

                //CSet setA = new CSet();
                //CSet setB = new CSet();

                //setA.Add("milk");
                //setA.Add("eggs");
                //setA.Add("bacon");

                //setB.Add("bacon");
                //setB.Add("eggs");
                //setB.Add("bread");

                //Console.WriteLine(setA);
                //Console.WriteLine(setB);

                //CSet setC = new CSet();
                //setC = setA.Union(setB);
                //Console.WriteLine(setC);

                //setC = setA.Difference(setB);
                //Console.WriteLine(setC);

                //CSet setA = new CSet();
                //CSet setB = new CSet();

                //setA.Add(1);
                //setA.Add(2);
                //setA.Add(3);

                //setB.Add(2);
                //setB.Add(3);

                //Console.WriteLine(setA);
                //Console.WriteLine(setB);

                //CSet setC = setA.Union(setB);
                //Console.WriteLine(setC);

                //const int SIZE = 19;
                //ArrayList theArray = new ArrayList(SIZE);
                //Random random = new Random();
                //for (int index = 0; index < SIZE;index++ )
                //{
                //    theArray.Add(random.Next(100) + 1);
                //}

                //Console.WriteLine();
                //foreach(object o in theArray)
                //{
                //    Console.Write(o.ToString()+",");
                //}

                //int[] iArray = (int[])theArray.ToArray(typeof(int));

                //Console.WriteLine();

                //ShellSort(iArray);

                //const int SIZE = 9;
                //Heap aHeap = new Heap(SIZE);
                //Random RandomClass = new Random();
                //for (int i = 0; i < SIZE;i++ )
                //{
                //    int rn = RandomClass.Next(1, 100);
                //    aHeap.Insert(rn);
                //}

                //aHeap.ShowArray();

                //Graph theGrahph = new Graph(13);
                //theGrahph.AddVertex("A");
                //theGrahph.AddVertex("B");
                //theGrahph.AddVertex("C");
                //theGrahph.AddVertex("D");
                //theGrahph.AddVertex("E");
                //theGrahph.AddVertex("F");
                //theGrahph.AddVertex("G");
                //theGrahph.AddVertex("H");
                //theGrahph.AddVertex("I");
                //theGrahph.AddVertex("J");
                //theGrahph.AddVertex("K");
                //theGrahph.AddVertex("L");
                //theGrahph.AddVertex("M");

                //theGrahph.AddEdge(0, 1);
                //theGrahph.AddEdge(1, 2);
                //theGrahph.AddEdge(2, 3);

                //theGrahph.AddEdge(0, 4);
                //theGrahph.AddEdge(4, 5);
                //theGrahph.AddEdge(5, 6);

                //theGrahph.AddEdge(0, 7);
                //theGrahph.AddEdge(7, 8);
                //theGrahph.AddEdge(8, 9);

                //theGrahph.AddEdge(0, 10);
                //theGrahph.AddEdge(10, 11);
                //theGrahph.AddEdge(11, 12);

                //theGrahph.DepthFirstSearch();
                //theGrahph.BreadthFirstSearch();
                //theGrahph.TopSort();
                //theGrahph.Mst();

                //Timing2 tObj = new Timing2();
                //Timing2 tObj2 = new Timing2();
                //int num = 42;
                //long fibNumber;
                //tObj.startTime();
                //fibNumber = recurFib(num);
                //tObj.stopTime();
                //Console.WriteLine("recurFib: " + fibNumber + ",cost: " + tObj.Result().TotalMilliseconds);

                //tObj2.startTime();
                //fibNumber = iterFib(num+1);
                //tObj2.stopTime();
                //Console.WriteLine("iterFib: " + fibNumber + ",cost: " + tObj2.Result().TotalMilliseconds);

                //Console.WriteLine("recurFib: "+recurFib(10));
                //Console.WriteLine("iterFib: " + iterFib(11));


                //背包问题
                //int capcity = 16;
                //int[] size = new int[] { 3, 4, 7, 8, 9 };
                //int[] values = new int[] { 4, 5, 10, 11, 13 };
                //int[] totval = new int[capcity + 1];
                //int[] best = new int[capcity + 1];
                //int n = values.Length;
                //for (int j = 0; j <= n - 1;j++)
                //{//遍历所有的物品
                //    for (int i = 0; i <= capcity;i++ )
                //    {//遍历所有的容量
                //        if(totval[i]<(totval[i-size(j)]+values[j]))
                //        {//
                //            totval[i] = totval[i - size(j)] + values[j];
                //            best[i] = j;
                //        }
                //    }
                //}
                double origAmount = 0.63;
                double toChange = origAmount;
                double remainAmount;
                int[] coins = new int[4];
                MakeChange(origAmount, out remainAmount, ref coins);
                ShowChange(coins);
            }
            public class Knapsack {//最优法是对应着，单位大小为1的物品，如果物品的大小不是1，而且不能分割，需要采取动态规划的方法。
                private float quantity;  //背包最大的容量
                SortedList item = new SortedList(); //存放毛毯信息的容器
                string itemList;
                public Knapsack(float max) {//背包最大的容量
                    this.quantity = max;
                }

                public void FillSack(ArrayList objects) {//装包函数,前提是objects 必须是按照价钱从小到大排序的
                    int pos = objects.Count - 1;
                    int totalUnits = 0;
                    float totalVal = 0.0F; //包内总共的价值
                    int tempTot = 0;
                    while (totalUnits < quantity) {//如果包内总共的物品大小 < 包的大小
                        tempTot += (((Carpet)objects[pos]).GetUnit());
                        if (tempTot <= quantity) {//这种类型所有的毛毯都可以带走
                            totalUnits += ((Carpet)objects[pos]).GetUnit(); //数量上的增加
                            totalVal += ((Carpet)objects[pos]).GetVal();  //总价值上的增加
                            item.Add(((Carpet)objects[pos]).GetItem(), ((Carpet)objects[pos]).GetUnit()); //名字，数量
                        } else {//这种毛毯已经没有办法全部都装下
                            float tempUnit = quantity - totalUnits; //还可以装下的
                            float tempVal = ((Carpet)objects[pos]).ItemVal() * tempUnit;
                            totalVal += tempVal;
                            item.Add(((Carpet)objects[pos]).GetItem(), tempUnit); //名字，数量
                        }
                        pos--;
                    }
                }
            }
            public class Carpet : IComparable {
                private string item;
                private float val; //单价
                private int unit;  //总数量
                public Carpet(string item, float val, int unit) {
                    this.item = item;
                    this.val = val;
                    this.unit = unit;
                }
                public int CompareTo(object c) {
                    return (this.val.CompareTo(((Carpet)c).val));
                }
                public int GetUnit() {//总数量
                    return unit;
                }
                public string GetItem() {//商品名称
                    return item;
                }
                public float GetVal() {//得到总价钱
                    return val * unit;
                }
                public float ItemVal() {//得到单价
                    return val;
                }
            }
            static void MakeChange(double origAmount, out double remainAmount, ref int[] coins) {
                remainAmount = 0.0;
                if ((origAmount % 0.25) < origAmount) {//如果origAmount>0.25
                    coins[3] = (int)(origAmount / 0.25);//需要多少25美分
                    remainAmount = origAmount % 0.25;
                    origAmount = remainAmount;
                }
                if ((origAmount % 0.1) < origAmount) {//如果origAmount>0.25
                    coins[2] = (int)(origAmount / 0.1);//需要多少25美分
                    remainAmount = origAmount % 0.1;
                    origAmount = remainAmount;
                }
                if ((origAmount % 0.05) < origAmount) {//如果origAmount>0.25
                    coins[1] = (int)(origAmount / 0.05);//需要多少25美分
                    remainAmount = origAmount % 0.05;
                    origAmount = remainAmount;
                }
                if ((origAmount % 0.01) < origAmount) {//如果origAmount>0.25
                    coins[0] = (int)(origAmount / 0.01);//需要多少25美分
                    remainAmount = origAmount % 0.01;
                }
            }
            static void ShowChange(int[] arr) {
                if (arr[3] > 0) {
                    Console.WriteLine("Number of 25 :" + arr[3]);
                }
                if (arr[2] > 0) {
                    Console.WriteLine("Number of 10 :" + arr[2]);
                }
                if (arr[1] > 0) {
                    Console.WriteLine("Number of 5 :" + arr[1]);
                }
                if (arr[0] > 0) {
                    Console.WriteLine("Number of 1 :" + arr[0]);
                }
            }
            static long recurFib(int n) {
                if (n < 2) {
                    return n;
                } else {
                    return recurFib(n - 1) + recurFib(n - 2);
                }

            }
            static long iterFib(int n) {
                int[] val = new int[n];
                if ((n == 1) || (n == 2)) {//Fibnoyi数1，2都是1
                    return 1;
                } else {
                    val[1] = 1;
                    val[2] = 1;
                    for (int i = 3; i <= n - 1; i++) {//注意0是第一个数,所以第n-1个数是第n
                        val[i] = val[i - 1] + val[i - 2];
                    }

                    return val[n - 1];
                }
            }
            public class Vertex {
                public bool wasVisited;
                public string label;

                public Vertex(string label) {
                    this.label = label;
                    this.wasVisited = false;
                }
            }
            public class Graph {
                public int NUM_VERTICES = 6;  //定点个数
                public Vertex[] vertices;
                private int[,] adjMatrix;  //边
                public int numVerts;
                public Graph(int numVertices) {
                    NUM_VERTICES = numVertices;
                    vertices = new Vertex[NUM_VERTICES];
                    adjMatrix = new int[NUM_VERTICES, NUM_VERTICES];
                    numVerts = 0;  //当前节点
                    for (int j = 0; j < NUM_VERTICES; j++) {//初始化所有的边都是不连通的
                        for (int k = 0; k < NUM_VERTICES; k++) {
                            adjMatrix[j, k] = 0;
                        }
                    }
                }
                //添加节点
                public void AddVertex(string strlabel) {
                    this.vertices[numVerts] = new Vertex(strlabel);
                    this.numVerts++;
                }
                public void AddEdge(int start, int end) {
                    adjMatrix[start, end] = 1;
                    //adjMatrix[end, start] = 1;
                }
                public void ShowVertex(int v) {
                    Console.Write(vertices[v].label + " ");
                }

                //得到没有后续的行数
                public int NoSucessor() {
                    bool isEdge;
                    for (int row = 0; row < NUM_VERTICES; row++) {
                        isEdge = false;//默认是没有后续节点
                        for (int col = 0; col < NUM_VERTICES; col++) {
                            if (adjMatrix[row, col] == 1) {
                                isEdge = true;
                                break;
                            }
                        }
                        if (!isEdge) {//如果没有边
                            return row;
                        }
                    }
                    //如果所有的边都有后缀
                    return -1;
                }

                //删除第vert节点，从0还是记数
                public void DelVetrix(int vert) {
                    if (vert != NUM_VERTICES - 1) {//如果不是最后一个节点，就需要MoveCol,MoveRow
                        for (int j = vert; j < NUM_VERTICES - 1; j++) {
                            vertices[j] = vertices[j + 1];
                        }
                        for (int row = vert; row < NUM_VERTICES - 1; row++) {
                            MoveRow(row, NUM_VERTICES);
                        }
                        for (int col = vert; col < NUM_VERTICES - 1; col++) {
                            MoveCol(col, NUM_VERTICES);
                        }
                    }
                    NUM_VERTICES--;//如果是最后一个节点，仅仅减少个数就可以了
                }

                //使用row+1，替换row
                private void MoveRow(int row, int length) {
                    for (int col = 0; col <= length - 1; col++) {
                        adjMatrix[row, col] = adjMatrix[row + 1, col];
                    }
                }

                private void MoveCol(int col, int length) {
                    for (int row = 0; row <= length - 1; row++) {
                        adjMatrix[row, col] = adjMatrix[row, col + 1];
                    }
                }

                public void TopSort() {
                    Stack<string> gStack = new Stack<string>();  //用于反向输出

                    while (NUM_VERTICES > 0) {//如果还有节点
                        int currVertex = NoSucessor();  //找到一个没有后缀的节点
                        if (currVertex == -1) {//说有说有节点都有后缀，就说明这个图含有“环”
                            Console.WriteLine("graph has ring.");
                            return;
                        }
                        gStack.Push(vertices[currVertex].label);
                        this.DelVetrix(currVertex); //删除这个节点
                    }

                    Console.WriteLine("Toplogical sorting order: ");
                    while (gStack.Count > 0) {
                        Console.Write(gStack.Pop() + ",");
                    }

                }

                //找到与第v个节点连通，并且没有被访问过的节点
                private int GetAdjUnvisitedVertex(int v) {
                    for (int j = 0; j <= NUM_VERTICES - 1; j++) {
                        if ((adjMatrix[v, j] == 1) && (vertices[j].wasVisited == false)) {
                            return j;
                        }
                    }

                    return -1;
                }

                public void DepthFirstSearch() {
                    Stack<int> gStack = new Stack<int>();
                    vertices[0].wasVisited = true; //认为第一个录入的节点是图的开始

                    ShowVertex(0);

                    gStack.Push(0);
                    int v;
                    while (gStack.Count > 0) {//如果栈里面还有元素
                        v = GetAdjUnvisitedVertex(gStack.Peek());
                        if (v == -1) {//说明栈定元素周围没有没有访问过的节点了。
                            gStack.Pop();//出栈
                        } else {
                            vertices[v].wasVisited = true;
                            ShowVertex(v);
                            gStack.Push(v);
                        }
                    }

                    //再重新初始化回去
                    for (int j = 0; j <= NUM_VERTICES - 1; j++) {
                        vertices[j].wasVisited = false;
                    }
                }

                //最小生成树
                public void Mst() {
                    Stack<int> gStack = new Stack<int>();
                    vertices[0].wasVisited = true; //认为第一个录入的节点是图的开始

                    ShowVertex(0);

                    gStack.Push(0);
                    int v, currv;
                    while (gStack.Count > 0) {//如果栈里面还有元素
                        currv = gStack.Peek(); //栈顶的当前元素、
                        v = GetAdjUnvisitedVertex(gStack.Peek());
                        if (v == -1) {//说明栈定元素周围没有没有访问过的节点了。
                            gStack.Pop();//出栈
                        } else {
                            vertices[v].wasVisited = true;
                            ShowVertex(currv);
                            ShowVertex(v);
                            Console.WriteLine();
                            gStack.Push(v);
                        }
                    }

                    //再重新初始化回去
                    for (int j = 0; j <= NUM_VERTICES - 1; j++) {
                        vertices[j].wasVisited = false;
                    }
                }


                public void BreadthFirstSearch() {
                    Queue<int> gQueue = new Queue<int>();
                    vertices[0].wasVisited = false;
                    ShowVertex(0);

                    gQueue.Enqueue(0);

                    int vert1, vert2;
                    while (gQueue.Count > 0) {
                        vert1 = gQueue.Dequeue();//出栈
                        vert2 = GetAdjUnvisitedVertex(vert1);//得到vert1的相邻节点中没有被访问过的
                        while (vert2 != -1) {
                            vertices[vert2].wasVisited = true;
                            ShowVertex(vert2);
                            gQueue.Enqueue(vert2);
                            vert2 = GetAdjUnvisitedVertex(vert1); //找下一个vert1的相邻节点
                        }
                    }

                    //重新初始化整个图
                    for (int i = 0; i <= NUM_VERTICES - 1; i++) {
                        vertices[i].wasVisited = false;
                    }
                }
            }
            //跳跃表
            //思路 : 从最高连层开始访问,利用这些连接,来遍历表,直到到达的数值大于要找到的数值为止,这个时候,回退到访问过的最后一个节点,并向下移动到下一层连接
            //重复相同的步骤,最终到达的连层会指引出所要查找的数值.
            //对巨大的链开销的解决方法:

            ////跳跃表节点类
            //public class SkipNode
            //{
            //    public int key;
            //    public object value;
            //    public SkipNode[] link; //用来存储指向其他节点的数组
            //    public SkipNode(int level,int key,object value)
            //    {
            //        this.key = key;
            //        this.value = value;
            //        link = new SkipNode[level];  //会指向几个其他节点
            //    }
            //}

            //public class SkipList
            //{
            //    private int maxLevel;  //跳跃表所允许的最大层数
            //    private int level;     //存储当前层
            //    private SkipNode header; //跳跃表的起始节点
            //    private float probalility; //存储当前链层的概率分布
            //    private const int NIL = Int32.MaxValue; //表示跳跃表末尾的特殊数的值
            //    private const int PROB = 0.5F; //层次的概率分布

            //    private void SkipList2(float probable,int maxLevel)
            //    {
            //        this.probalility = probable;
            //        this.maxLevel = maxLevel;
            //        level = 0;
            //        header = new SkipNode(maxLevel, 0, null);
            //        SkipNode nilElement = new SkipNode(maxLevel, 0, null);
            //        for(int i=0;i<=maxLevel;i++)
            //        {
            //            header.link[i] = nilElement;
            //        }
            //    }

            //    public SkipList(long maxNodes)
            //    {
            //        //概率,最大多少层
            //        this.SkipList2(PROB, (int)(Math.Ceiling(Math.Log(maxNodes) / Math.Log(1 / PROB)) - 1));
            //    }

            //    private int GenRandomLevel()
            //    {
            //        int newLevel = 0;
            //        Random r = new Random();
            //        long ran = r.NextDouble();
            //        while((newLevel<maxLevel)&&(ran<probalility))
            //        {
            //            newLevel++;
            //        }
            //        //得到一个随机的层数
            //        return newLevel;
            //    }
            //}



            //红黑树
            //原则如下:
            //1 树中每个节点都标记成 红色 或 黑色
            //2 把根节点标记为 黑色
            //3 如果某个节点是 红色 ,那么它的子节点必须是 黑色
            //4 从一个节点到一个叶子节点的每一条路上必须包含相同数量的黑色节点.

            //AVL树
            //public class Node : IComparable
            //{
            //    public object element;
            //    public Node left;  //左孩子
            //    public Node right; //右孩子
            //    public int height; //高度

            //    public Node(object data,Node lt,Node rt)
            //    {
            //        element = data;
            //        left = lt;
            //        right = rt;
            //        height = 0; //高度为0
            //    }

            //    public Node(object data)
            //    {
            //        element = data;
            //        left = null;
            //        right = null;
            //    }

            //    public int CompareTo(object obj)
            //    {
            //        return (((int)element).CompareTo((int)obj));
            //    }

            //    public int GetHeight()
            //    {
            //        if(this == null)
            //        {
            //            return -1;
            //        }
            //        else
            //        {
            //            return this.height;
            //        }
            //    }

            //    private Node RotateWithLeftChild(Node n2)
            //    {//对不平衡点n2的LL旋转
            //        Node n1 = n2.left;
            //        n2.left = n1.right;
            //        n1.right = n2;
            //        n2.height = Math.Max(n2.left.GetHeight(), n2.right.GetHeight()) + 1;
            //        n1.height = Math.Max(n1.left.GetHeight(), n2.GetHeight()) + 1;
            //        return n1;
            //    }

            //    private Node RotateWithRightChild(Node n1)
            //    {//对不平衡点n1的RR旋转
            //        Node n2 = n1.right;
            //        n1.right = n2.left;
            //        n2.left = n1;
            //        n1.height = Math.Max(n1.left.GetHeight(), n1.right.GetHeight()) + 1;
            //        n2.height = Math.Max(n1.GetHeight(), n2.right.GetHeight()) + 1;
            //        return n2;
            //    }

            //    private Node DoubleWithLeftChild(Node n3)
            //    {//对n3进行LR旋转, 先对n3的左孩子进行右旋转,然后对n3进行左旋转
            //        n3.left = RotateWithRightChild(n3.left);
            //        return RotateWithLeftChild(n3);
            //    }

            //    private Node DoubleWithRightChild(Node n4)
            //    {//对n4进行RL旋转,先对n4的右孩子进行
            //        n4.right = RotateWithLeftChild(n4.right);
            //        return RotateWithRightChild(n4);
            //    }
            //    private Node Insert(object item, Node n)
            //    {//在节点n上插入一个新节点，节点值为item
            //        if (n == null)
            //        {
            //            n = new Node(item, null, null);
            //        }
            //        else if (((int)item).CompareTo(((int)n.element)) < 0)
            //        {//如果要插入的节点比当前节点小,就插入到左孩子上.
            //            n.left = Insert(item, n.left); //递归的插入
            //            if (n.left.GetHeight() - n.right.GetHeight() == 2)
            //            {//如果不平衡了
            //                n = n.RotateWithLeftChild(n);
            //            }
            //            else
            //            {
            //                n = n.DoubleWithLeftChild(n);
            //            }
            //        }
            //        else if (((int)item).CompareTo(((int)n.element)) > 0)
            //        {
            //            n.right = Insert(item, n.right);
            //            if (n.right.GetHeight() - n.right.GetHeight() == 2)
            //            {//不平衡
            //                n = n.RotateWithRightChild(n);
            //            }
            //            else
            //            {
            //                n = n.DoubleWithRightChild(n);
            //            }
            //        }
            //        else
            //        {

            //        }
            //        n.height = Math.Max(n.left.GetHeight(), n.right.GetHeight()) + 1;

            //        return n;
            //    }
            //}
        }
    }
    /*二分查找（强调效率）
     * 终于搞清楚了C#二进制的一些关键操作了,解决了微软面试题，求数组中两两之差绝对值最小的值O(N)最少内存限制的问题!
        研究了好几天,写出来一个看起来象O(n)的算法,O(nlog)就不用写了.
        思路是桶排序O(N)复杂度,为了节省空间,采用了Byte[]数组,1个byte代表8个数字的有无.
        回头整理公布一下C#二进制运算的一些重要操作.
     * http://bbs.csdn.net/topics/190046028
     */
    namespace Test6 {
        /*解释
         * sorry,对于没看过CSDN首页精华贴的人的确不知道这题目的
            数组中两两之差绝对值最小的值,意思是在线段上随便扔一些点
            比如:输入1,3,6,8,9,12
            结果就是1,(是8和9之间距离最小).
            O(N)就是复杂度是和输入的数量成线性关系.
            这个题目要排序,大量数字排序,一般采用快速排序,AVL树等做法,时间复杂度是NlogN>N
            我采用了桶排序,为了节省空间,使用了Byte[]数组,时间复杂度是N
            因为输入可能是几个G分布在全部整数范围内的数字,所以算法和数据结构要特殊考虑.
            如果看不懂也是正常的,因为大家工作中很少涉及2进制运算,很少涉及内存和计算复杂度的要求.
            我这样做,纯粹是给自己补课和乐趣.
            2进制运算代码可读性差,但是可以作到几乎是最快的速度.不信你尝试一下,5000万数据排序,几秒就完成,这是其他算法不可能作到的.
            近期一些搜索引擎相关的公司特别注重这些超级变态的算法和数据结构问题,百度,Google,腾讯在招聘的时候频繁出现这样的题目
            输入的级别都是以G计算的,比如寻找不重复数字,中位数,众数之类的,计算规模挑战了现有的计算机.
            如果没有2进制基础是根本解答不了这样的问题的.
            多数这类问题都可以演变为排序问题,排过序查找一个元素复杂度只有logN次,比如1024个元素的数组,不排序最坏可能要查找1024次,排过序最坏只要10次(二分查找),而且输入量越大越合算, N-logN 
            这就是差别!
            很多非计算机专业毕业的人虽然可以胜任工作,但是缺少理论基础,还有些计算机专业毕业的人把知识都还给老师了.找时间恶补一下是值得的.
            还有,如果你感兴趣的话,这些问题求解本身就能给你带来很大的乐趣,改变你想问题的角度.
            世界观和方法论.....
            悟空,你明白了吗?走,天竺.
         */
        [TestClass]
        public class Program {
            [TestMethod]
            public void Main1() {
                int n = 100;
                int[] a = new int[n];
                Random rand = new Random();
                int min = int.MaxValue;
                int max = int.MinValue;
                Console.WriteLine("产生了" + n + "个数据的实验数组,");
                Console.WriteLine("本程序适用于int.MinValue到int.MaxValue范围，请自行修改输入的量和范围");
                for (int i = 0; i < n; i++) {
                    //赋值并且取到最大最小值
                    //a[i] = rand.Next(int.MinValue, int.MaxValue);
                    a[i] = rand.Next(-100, 100);
                    if (a[i] < min) { min = a[i]; }
                    if (a[i] > max) { max = a[i]; }
                    Console.Write(a[i] + " ");
                }
                Console.WriteLine();
                Console.WriteLine("在O(n)内得到最大最小分别是：");
                Console.WriteLine(max + "和" + min);

                long offset = (long)max + Math.Abs((long)min);
                //规划数组的长度。每个byte有8位长
                int len = (int)(offset >> 3) + 1;
                Byte[] B = new Byte[len];
                int kkkk = 0;
                bool IsSame = false;//是否有重合点标记

                //O(n)的时间内分配到了Byte[]中。

                for (int i = 0; i < n; i++) {
                    offset = (long)a[i] - (long)min;
                    int index = (int)(offset >> 3);
                    int temp = B[index];
                    //把末k位变成1
                    //把右数第k位变成1 例如：(00101001->00101101,k=3)     x | (1 << (k-1))

                    int tempOffSet = (1 << ((int)(offset & 7)));
                    //判断重合
                    if (!IsSame) {
                        kkkk = temp & tempOffSet;
                        if ((temp & tempOffSet) >= 1) {
                            IsSame = true;
                            //如果0算最小距离就在这里退出吧。本代码判断重合，但没把0作为结果。                        
                        }
                    }
                    int bbb = B[index];
                    B[index] |= (Byte)(tempOffSet);
                    int aaa = B[index];

                }
                //最小距离初始为最大。

                Console.WriteLine("在O(n)的时间内分配到了Byte[]中，正在计算最小距离，请稍候。。。。。");

                long minABS = long.MaxValue;
                long lastIndex = -1;

                //在常数范围内循环，复杂度不增加。最坏的情况是32*int.MaxValue次。

                for (int i = 0; i < B.Length; i++) {
                    //if (B[i] == 0) { continue; }
                    //在常数范围内循环，复杂度不增加。
                    for (int k = 0; k < 8; k++) {
                        if (((B[i] >> k) & 1) == 1) {
                            if (lastIndex >= 0) {
                                long temp = ((long)i << 3) + k - lastIndex;
                                if (temp < minABS) {
                                    minABS = temp;
                                    Console.WriteLine("目前得到了最小距离：" + minABS);
                                }
                            }
                            lastIndex = (i << 3) + k;
                        }
                    }
                }
                if (IsSame) { Console.WriteLine("有重合点"); } else { Console.WriteLine("无重合点"); }
                Console.WriteLine("不考虑重合最小距离是：" + minABS);
                Console.WriteLine("总复杂度是：O(n)");
            }
        }
    }
    /* 来自百度问答
     * 怎样c#控制台写牛顿迭代法
     */
    namespace Test5 {
        delegate double Function(double x);
        [TestClass]
        public class Program {
            [TestMethod]
            public void Test1() {
                double result = NewtonMethod(Func, Derivative, 0.5, 6);
                Console.WriteLine(result);
            }

            static double NewtonMethod(Function func, Function derivative, double x0, int times) {
                double result = x0;
                for (int i = 1; i <= times; i++) {
                    result = result - func(result) / derivative(result);
                }
                return result;
            }

            static double Func(double x) {
                return Math.Cos(x) - Math.Pow(x, 3);
            }

            static double Derivative(double x) {
                return -Math.Sin(x) - 3 * Math.Pow(x, 2);
            }
        }
    }
    /* 来自对csdn论坛的解答
     * 登录时段统计
     */
    namespace Test4 {
        [TestClass]
        public class LoginTime {
            [TestMethod]
            public void Statistics() {
                var loginTimes = new DateTime[1000000];//已知登录数据
                var ran = new Random();
                var now = DateTime.Now;
                var xx = 12 * 60 * 60;
                for (int i = 0; i < 1000000; i++) {
                    loginTimes[i] = now.AddSeconds(ran.Next(xx) * Math.Pow(-1, i));
                }
                var x = new List<int>();
                var x2 = 24;//把一天的登录数据分成24份 意思是每小时段做统计
                for (int i = 0; i < x2; i++) {
                    x.Add(0);
                }
                foreach (var item in loginTimes) {
                    switch (item.Hour) {
                        case 0: x[0]++; break;
                        case 1: x[1]++; break;
                        case 2: x[2]++; break;
                        case 3: x[3]++; break;
                        case 4: x[4]++; break;
                        case 5: x[5]++; break;
                        case 6: x[6]++; break;
                        case 7: x[7]++; break;
                        case 8: x[8]++; break;
                        case 9: x[9]++; break;
                        case 10: x[10]++; break;
                        case 11: x[11]++; break;
                        case 12: x[12]++; break;
                        case 13: x[13]++; break;
                        case 14: x[14]++; break;
                        case 15: x[15]++; break;
                        case 16: x[16]++; break;
                        case 17: x[17]++; break;
                        case 18: x[18]++; break;
                        case 19: x[19]++; break;
                        case 20: x[20]++; break;
                        case 21: x[21]++; break;
                        case 22: x[22]++; break;
                        case 23: x[23]++; break;
                    }
                }
                foreach (var item in x) {
                    Console.WriteLine(item);
                }
            }
        }
    }
    /* 来自csdn论坛提问的思考
     * 斗地主AI
     */
    namespace Test3 {

    }
    /*
     * 今天面试时面试官出了这么一道题：说你在某个起点A,此处有无数个能量块，你要到100公里处的B,你每走1公里消耗1个能量块，而你每次最多携带50个能量块，请问走到B最少需要多少能量块？
谁晓得这类问题的思路呀？？
     * 至少700个能量块
        初始情况（至少有50个能量块可用）
        每次选择都消耗掉50个能量块
        选择a 不返回 一次最远能走50
        选择b 要返回 一次最远能走25（无意义的浪费）
        选择c 要返回 还要留下足够下次不返回的能量块
        可以设前进距离x 下次来到x这点的时候消耗x个能量块 然后在这里补充x个能量块（补满50个）然后回到初始情况
        所以有x = 50 - 2x， x = 50/3

        可以看出 如果通过一系列选择 使得前进至50的时候能够补满50个能量块 再加一次选择a就可以到达100处 即目的地

        在距离x处最多补充x的能量块（身上不能超过50）所以第一个补给点是x
        同理 第二个补给点是2x 第三个补给点是3x
        需要一次选择c来存放x个能量块到补给点1
        需要三次选择c来存放x个能量块到补给点2 （先通过2次选择c存放2x个能量块到补给点1，然后第三次可以存x个能量块去补给点2）
        可以看出这就是个三进制存储
        所以要达到距离100 需要三进制（每个补给点为一个数位）的值达到111（即前三个补给点都存放x个能量块）
        三进制的111等于十进制的13，这个时候再触发一次选择a共14次选择所以是14*50 = 700个能量块

        可以看出 要达到50+m*(50/3)的距离（m为整数） 最少需要 3^(m-1)+3^(m-2)+...+3^0 次选择c 加上 1次选择a
     */
    namespace Test1 {

    }
    /*
     * 1, 假设A上台阶，一次可以跨1层，2层或3层，问A上50层台阶，有多少种走法？
        假设A上台阶，一次可以跨1层，2层，3层.. 或m层，问A上n层台阶，有多少种走法？
        其中，m和n都是正整数，并且 m <= n, m <= 10, n <= 50
        请编程解决这个问题，并详细说明解题思路。

        2，请设计一套对n个字符进行全排列的算法。
        如果对该算法输出全排列顺序分别标记序号，从1到n!`
        那么，给出low, high，能否不算出所有排列，而直接输出第low个到第high个的排列方式。
        请写出示例代码，并详细说明解题思路。

        3，一栋楼有N层，要去每一层的人数分别为p[1], p[2], ...，p[n]，如果电梯只停1次，问停哪一层，可以让所有人走的楼层最少。
        如果走路上一层楼耗费的能量为k1, 走路下一层楼消耗的能量为k2，坐电梯上一层楼消耗的能量为k3，问停哪一层，可以让所有人消耗能量最少。
        请编程解决这个问题，并详细说明解题思路。

        4，如果你很熟悉STL，请尝试做下面题目：
        a，如何将大量有序数据(例如有100万条有序节点的vector)，快速添加到map中去
        b，一个vector中有100万条数据，请以最高的效率，删除第5，10，15项的内容

     * 5，在云存储计算中心，大量的文件存储在N台服务器组成的集群中，每个文件都有一个独立且唯一的编号（ID），我们根据 ID % N 将文件的实际存储分配到N台服务器中。但是如果有一台服务器宕机，或者需要添加一台服务器时，由于N的变化，会造成大量的访问错误，需要重新对文件的存储进行分配（需要把文件从一台机器复制到另一台机器）。

        能不能换一种策略，使得在充分利用每台服务器的存储空间同时，尽可能减少服务器数量的变化对文件存储重分配造成的开销，如果N台服务器的存储空间各不相同，如何调整你的策略。


        6，有两个大于1且不相等的自然数。A知道两个数的乘积，B知道两个数的和。
        B说：我不知道这两个数是多少，但我确定你也不知道
        A看了看乘积说：那现在我就知道这两个数是多少了。
        B想了想说：嗯，现在我也知道这两个数是多少了。
        请问，这两个数分别是多少。

        7，设计一套内存地址描述算法和数据结构，要求如下：
        1)内存地址从0开始，到无穷大，初始内存都是未使用。
        2)申请内存块算法，输入申请大小，输出申请到的内存的起始地址，并将此块内存标记为已使用，申请内存块时，不能覆盖到已使用的内存块。
        3)在可能申请到的内存地址中，必须随机。即如果[0, 0x1000]都是未使用的内存，申请0x100大小的内存，申请到的地址必须是从[0, 0xF00]中随机。
        4)如果连续多次进行申请内存操作，会对该段内存产生碎片，申请内存的时候，要尽可能使用中间的碎片进行申请，只有在所有碎片都无法申请的所需大小时，才能向内存最后的无穷大空间中申请内存。
        5)不需要释放内存块的功能，在大量碎片（超过2w个）的情况下，申请速度会大大降低（浪费在查询碎片内存块上），请尽量保证最快的申请内存块速度。
     */
    namespace Test2 {

    }
}
